import userManager from './user.js'

const BASE_URL = "https://s10.v100.vip:6318/prod-api";
// const BASE_URL = "localhost:8080"
// 请求拦截器
const requestInterceptor = (config) => {
	// 获取 token
	const token = userManager.getToken()

	// 确保有 header 对象
	if (!config.header) {
		config.header = {}
	}

	// 添加基础 URL - 确保URL格式正确
	if (config.url.startsWith('/')) {
		config.url = `${BASE_URL}${config.url}`
	} else {
		config.url = `${BASE_URL}/${config.url}`
	}

	// 如果有 token，添加到请求头
	if (token) {
		config.header['Authorization'] = `Bearer ${token}`
	}

	// 添加默认的 content-type
	if (!config.header['content-type']) {
		config.header['content-type'] = 'application/json'
	}

	// console.log('请求配置:', config)
	return config
}

// 响应拦截器
const responseInterceptor = (response) => {
	// 处理 token 过期等情况
	if (response?.data?.code === 401) {
		// token 过期，清除登录状态
		userManager.logout()

		// 跳转到登录页面
		uni.navigateTo({
			url: '/subPack/login/login'
		})
	}

	return response
}

// 封装请求方法
const request = (options) => {
	// 应用请求拦截器
	const config = requestInterceptor(options)

	return new Promise((resolve, reject) => {
		uni.request({
			...config,
			success: (res) => {
				try {
					// 应用响应拦截器
					const response = responseInterceptor(res);
					const body = response.data;
					console.log('res', res, response, body)
					// 如果响应体不存在或不是对象，直接返回
					if (!body || typeof body !== 'object') {
						console.error('响应数据格式错误:', body);
						resolve({});
						return;
					}

					// 如果响应体没有code字段，直接返回整个响应体
					if (body.code == undefined) {
						resolve(body);
						return;
					}

					if (body.code == 200) {
						// 检查是否存在分页数据结构
						if (body.data && (body.data.rows !== undefined || body.data.list !==
								undefined)) {
							// 服务端返回的是 data.rows 或 data.list 形式的分页数据
							const result = {
								...body.data
							};

							// 如果存在 list 而不是 rows，统一处理为 rows
							if (result.list !== undefined && result.rows === undefined) {
								result.rows = result.list;
								delete result.list;
							}

							// 确保 rows 是数组
							if (!Array.isArray(result.rows)) {
								console.error('返回的rows不是数组:', result.rows);
								result.rows = [];
							}

							// 确保有 totalPage
							if (result.totalPage === undefined && result.total !== undefined) {
								result.totalPage = Math.ceil(result.total / (result.pageSize ||
									10));
							}

							resolve(result);
						} else if (body.rows !== undefined || body.list !== undefined) {
							// 服务端直接返回 rows 或 list 形式的分页数据
							const result = {};

							// 统一处理为 rows
							if (body.list !== undefined) {
								result.rows = Array.isArray(body.list) ? body.list : [];
							} else {
								result.rows = Array.isArray(body.rows) ? body.rows : [];
							}

							// 处理分页信息
							result.total = body.total !== undefined ? body.total : result.rows
								.length;
							result.totalPage = body.totalPage || (result.total ? Math.ceil(
								result.total / (body.pageSize || 10)) : 1);
							result.pageNum = body.pageNum || body.current || 1;
							result.pageSize = body.pageSize || 10;

							resolve(result);
						} else {
							// 非分页数据，直接返回
							resolve(body.data || body.result || body);
						}
					} else {
						// 显示错误提示
						const errorMsg = body.msg || `请求失败，错误码: ${body.code}`;
						uni.showToast({
							title: errorMsg,
							icon: 'none',
							duration: 2000
						});
						reject(errorMsg)
					}
				} catch (err) {
					console.error('响应处理异常:', err);
					uni.showToast({
						title: '数据处理异常',
						icon: 'none',
						duration: 2000
					});
					resolve({});
				}
			},
			fail: (err) => {
				console.error('网络请求失败:', err);
				uni.showToast({
					title: '网络连接失败',
					icon: 'none',
					duration: 2000
				});
				reject(err)
			}
		})
	})
}

export default request